home *** CD-ROM | disk | FTP | other *** search
/ Workbench Add-On / Workbench Add-On - Volume 1.iso / Text / Edit / ElVIs / src / ref.c < prev    next >
C/C++ Source or Header  |  1992-04-07  |  11KB  |  522 lines
  1. /* ref2.c */
  2.  
  3. /* This is a totally rewritten version of ref.  This version looks for the
  4.  * desired function name in the "tags" file, and then reads the header out
  5.  * from the source file.  There is no longer any need for a "refs" file.
  6.  *
  7.  * Usage:    ref [-a] [-t] [-f file] [-c class] tag
  8.  * Options:    -t       output tag info, not the description
  9.  *        -f file       default filename for static functions
  10.  *        -c class   default class names for class functions
  11.  */
  12.  
  13. #include <stdio.h>
  14. #include "config.h"
  15. extern char    *getenv();
  16. extern char    *fgets();
  17.  
  18.  
  19. /* This is the default path that is searched for tags */
  20. #if OSK
  21. # define DEFTAGPATH ".:/dd/defs:/dd/defs/sys:/dd/usr/src/lib:../lib:/dd/usr/lib"
  22. #else
  23. # if ANY_UNIX
  24. #  define DEFTAGPATH ".:/usr/include:/usr/include/sys:/usr/src/lib:../lib:/usr/local/lib"
  25. # else
  26. #  if MSDOS || TOS
  27. #   define DEFTAGPATH ".;C:\\include;C:\\include\\sys;C:\\lib;..\\lib"
  28. #   define SEP ';'
  29. #  else
  30. #   if AMIGA
  31. #    define DEFTAGPATH ".;Include:;Include:sys"
  32. #    define SEP ';'
  33. #   else /* any other OS */
  34. #    define DEFTAGPATH "."
  35. #   endif
  36. #  endif
  37. # endif
  38. #endif
  39.  
  40. #ifndef SEP
  41. # define SEP ':'
  42. #endif
  43.  
  44.  
  45. /* These variables reflect the command-line options given by the user. */
  46. int    taginfo;    /* boolean: give only the tag info? (not header?) */
  47. char    *def_file;    /* default filename for static functions */
  48. char    *def_class;    /* default classname for class members */
  49. int    colons;        /* #colons in tag: 0=normal, 1=static, 2=member */
  50.  
  51. /* This function checks for a tag in the "tags" file of given directory.
  52.  * If the tag is found, then it returns a pointer to a static buffer which
  53.  * contains the filename, a tab character, and a linespec for finding the
  54.  * the tag.  If the tag is not found in the "tags" file, or if the "tags"
  55.  * file cannot be opened or doesn't exist, then this function returns NULL.
  56.  */
  57. char *cktagdir(tag, dir)
  58.     char    *tag;    /* name of the tag to look for */
  59.     char    *dir;    /* name of the directory to check */
  60. {
  61.     char    buf[BLKSIZE];
  62.     static char found[BLKSIZE];
  63.     FILE    *tfile;
  64.     int    len;
  65.  
  66. #if AMIGA
  67.     if (dir[strlen(dir) - 1] == COLON)
  68.         sprintf(buf, "%s%s", dir, TAGS);   /* no slash after colon. */
  69.     else
  70. #endif
  71.     /* construct the name of the "tags" file in this directory */
  72.     sprintf(buf, "%s%c%s", dir, SLASH, TAGS);
  73.  
  74.     /* Try to open the tags file.  Return NULL if can't open */
  75. #if AMIGA
  76.     if (buf[0] == '.' && buf[1] == SLASH)
  77.         tfile = fopen(&buf[2], "r");
  78.     else
  79. #endif
  80.     tfile = fopen(buf, "r");
  81.     if (!tfile)
  82.     {
  83.         return (char *)0;
  84.     }
  85.  
  86.     /* compute the length of the tagname once */
  87.     len = strlen(tag);
  88.  
  89.     /* read lines until we get the one for this tag */
  90.     found[0] = '\0';
  91.     while (fgets(buf, sizeof buf, tfile))
  92.     {
  93.         /* is this the one we want? */
  94.         if (!strncmp(buf, tag, len) && buf[len] == '\t')
  95.         {
  96.             /* we've found a match -- remember it */
  97.             strcpy(found, buf);
  98.  
  99.             /* if there is no default file, or this match is in
  100.              * the default file, then we've definitely found the
  101.              * one we want.  Break out of the loop now.
  102.              */
  103.             if (!def_file || !strncmp(&buf[len + 1], def_file, strlen(def_file)))
  104.             {
  105.                 break;
  106.             }
  107.         }
  108.     }
  109.  
  110.     /* we're through reading */
  111.     fclose(tfile);
  112.  
  113.     /* if there's anything in found[], use it */
  114.     if (found[0])
  115.     {
  116.         return &found[len + 1];
  117.     }
  118.  
  119.     /* else we didn't find it */
  120.     return (char *)0;
  121. }
  122.  
  123. /* This function reads a single textline from a binary file.  It returns
  124.  * the number of bytes read, or 0 at EOF.
  125.  */
  126. int getline(buf, limit, fp)
  127.     char    *buf;    /* buffer to read into */
  128.     int    limit;    /* maximum characters to read */
  129.     FILE    *fp;    /* binary stream to read from */
  130. {
  131.     int    bytes;    /* number of bytes read so far */
  132.     int    ch;    /* single character from file */
  133.  
  134.     for (bytes = 0, ch = 0; ch != '\n' && --limit > 0 && (ch = getc(fp)) != EOF; bytes++)
  135.     {
  136. #if MSDOS || TOS
  137.         /* since this is a binary file, we'll need to manually strip CR's */
  138.         if (ch == '\r')
  139.         {
  140.             continue;
  141.         }
  142. #endif
  143.         *buf++ = ch;
  144.     }
  145.     *buf = '\0';
  146.  
  147.     return bytes;
  148. }
  149.  
  150.  
  151. /* This function reads a source file, looking for a given tag.  If it finds
  152.  * the tag, then it displays it and returns TRUE.  Otherwise it returns FALSE.
  153.  * To display the tag, it attempts to output any introductory comment, the
  154.  * tag line itself, and any arguments.  Arguments are assumed to immediately
  155.  * follow the tag line, and start with whitespace.  Comments are assumed to
  156.  * start with lines that begin with "/*", "//", "(*", or "--", and end at the
  157.  * tag line or at a blank line.
  158.  */
  159. int lookup(dir, entry)
  160.     char    *dir;    /* name of the directory that contains the source */
  161.     char    *entry;    /* source filename, <Tab>, linespec */
  162. {
  163.     char    buf[BLKSIZE];    /* pathname of sourcefile */
  164.     long    lnum;        /* line number */
  165.     long    here;        /* seek position where current line began */
  166.     long    comment;    /* seek position of introductory comment, or -1L */
  167.     FILE    *sfile;        /* used for reading the source file */
  168.     int    len;        /* length of string */
  169.     char    *ptr;
  170.  
  171.  
  172.     /* construct the pathname of the source file */
  173.     strcpy(buf, dir);
  174.     ptr = buf + strlen(buf);
  175. #if AMIGA
  176.     if (ptr[-1] != COLON)
  177. #endif
  178.     *ptr++ = SLASH;
  179.     while (*entry != '\t')
  180.     {
  181.         *ptr++ = *entry++;
  182.     }
  183.     *ptr = '\0';
  184.     entry++;
  185.  
  186.     /* searching for string or number? */
  187.     if (*entry >= '0' && *entry <= '9')
  188.     {
  189.         /* given a specific line number */
  190.         lnum = atol(entry);
  191.         entry = (char *)0;
  192.     }
  193.     else
  194.     {
  195.         /* given a string -- strip off "/^" and "$/\n" */
  196.         entry += 2;
  197.         len = strlen(entry) - 2;
  198.         if (entry[len - 1] == '$')
  199.         {
  200.             entry[len - 1] = '\n';
  201.         }
  202.         lnum = 0L;
  203.     }
  204.  
  205.     /* Open the file.  Note that we open the file in binary mode even
  206.      * though we know it is a text file, because ftell() and fseek()
  207.      * don't work on text files.
  208.      */
  209. #if MSDOS || TOS
  210.     sfile = fopen(buf, "rb");
  211. #else
  212. # if AMIGA
  213.     if (buf[0] == '.' && buf[1] == SLASH)
  214.         sfile = fopen(&buf[2], "r");
  215.     else
  216. # endif
  217.     sfile = fopen(buf, "r");
  218. #endif
  219.     if (!sfile)
  220.     {
  221.         /* can't open the real source file.  Try "refs" instead */
  222. #if AMIGA
  223.         if (dir[strlen(dir) - 1] == COLON)
  224.             sprintf(buf, "%srefs", dir);
  225.         else
  226. #endif
  227.         sprintf(buf, "%s%crefs", dir, SLASH);
  228. #if MSDOS || TOS
  229.         sfile = fopen(buf, "rb");
  230. #else
  231. # if AMIGA
  232.         if (buf[0] == '.' && buf[1] == SLASH)
  233.             sfile = fopen(&buf[2], "r");
  234.         else
  235. # endif
  236.         sfile = fopen(buf, "r");
  237. #endif
  238.         if (!sfile)
  239.         {
  240.             /* failed! */
  241.             return 0;
  242.         }
  243.     }
  244.  
  245.     /* search the file */
  246.     for (comment = -1L; here = ftell(sfile), getline(buf, BLKSIZE, sfile) > 0; )
  247.     {
  248.         /* Is this the start/end of a comment? */
  249.         if (comment == -1L)
  250.         {
  251.             /* starting a comment? */
  252.             if (buf[0] == '/' && buf[1] == '*'
  253.              || buf[0] == '/' && buf[1] == '/'
  254.              || buf[0] == '(' && buf[1] == '*'
  255.              || buf[0] == '-' && buf[1] == '-')
  256.             {
  257.                 comment = here;
  258.             }
  259.         }
  260.         else
  261.         {
  262.             /* ending a comment? */
  263.             if (buf[0] == '\n' || buf[0] == '#')
  264.             {
  265.                 comment = -1L;
  266.             }
  267.         }
  268.  
  269.         /* is this the tag line? */
  270.         if (--lnum == 0L || (entry && !strncmp(buf, entry, len)))
  271.         {
  272.             /* if there were introductory comments, show them */
  273.             if (comment != -1L)
  274.             {
  275.                 fseek(sfile, comment, 0);
  276.                 while (comment != here)
  277.                 {
  278.                     getline(buf, BLKSIZE, sfile);
  279.                     fputs(buf, stdout);
  280.                     comment = ftell(sfile);
  281.                 }
  282.  
  283.                 /* re-fetch the tag line */
  284.                 fgets(buf, BLKSIZE, sfile);
  285.             }
  286.  
  287.             /* show the tag line */
  288.             fputs(buf, stdout);
  289.  
  290.             /* show any argument lines */
  291.             while (getline(buf, BLKSIZE, sfile) > 0
  292.                 && buf[0] != '#'
  293.                 && strchr(buf, '{') == (char *)0)
  294.             {
  295.                 fputs(buf, stdout);
  296.             }
  297.  
  298.             /* Done!  Close the file, and return TRUE */
  299.             fclose(sfile);
  300.             return 1;
  301.         }
  302.     }
  303.  
  304.     /* not found -- return FALSE */
  305.     return 0;
  306. }
  307.  
  308. /* This function searches through the entire search path for a given tag.
  309.  * If it finds the tag, then it displays the info and returns TRUE;
  310.  * otherwise it returns FALSE.
  311.  */
  312. int find(tag)
  313.     char    *tag;    /* the tag to look up */
  314. {
  315.     char    *tagpath;
  316.     char    dir[80];
  317.     char    *ptr;
  318.     int    len;
  319.  
  320.     if (colons == 1)
  321.     {
  322.         /* looking for static function -- only look in current dir */
  323.         tagpath = ".";
  324.     }
  325.     else
  326.     {
  327.         /* get the tagpath from the environment.  Default to DEFTAGPATH */
  328.         tagpath = getenv("TAGPATH");
  329.         if (!tagpath)
  330.         {
  331.             tagpath = DEFTAGPATH;
  332.         }
  333.     }
  334.  
  335.     /* for each entry in the path... */
  336.     while (*tagpath)
  337.     {
  338.         /* Copy the entry into the dir[] buffer */
  339.         for (ptr = dir; *tagpath && *tagpath != SEP; tagpath++)
  340.         {
  341.             *ptr++ = *tagpath;
  342.         }
  343.         if (*tagpath == SEP)
  344.         {
  345.             tagpath++;
  346.         }
  347.  
  348.         /* if the entry ended with "/tags", then strip that off */
  349.         len = strlen(TAGS);
  350.         if (&dir[len] < ptr && ptr[-len - 1] == SLASH && !strncmp(&ptr[-len], TAGS, len))
  351.         {
  352.             ptr -= len + 1;
  353.         }
  354.  
  355.         /* if the entry is now an empty string, then assume "." */
  356.         if (ptr == dir)
  357.         {
  358.             *ptr++ = '.';
  359.         }
  360.         *ptr = '\0';
  361.  
  362.         /* look for the tag in this path.  If found, then display it
  363.          * and exit.
  364.          */
  365.         ptr = cktagdir(tag, dir);
  366.         if (ptr)
  367.         {
  368.             /* just supposed to display tag info? */
  369.             if (taginfo)
  370.             {
  371.                 /* then do only that! */
  372.                 if (strcmp(dir, "."))
  373.                 {
  374.                     printf("%s%c%s", dir, SLASH, ptr);
  375.                 }
  376.                 else
  377.                 {
  378.                     /* avoid leading "./" if possible */
  379.                     fputs(ptr, stdout);
  380.                 }
  381.                 return 1;
  382.             }
  383.             else
  384.             {
  385.                 /* else look up the declaration of the thing */
  386.                 return lookup(dir, ptr);
  387.             }
  388.         }
  389.     }
  390.  
  391.     /* if we get here, then the tag wasn't found anywhere */
  392.     return 0;
  393. }
  394.  
  395. void usage()
  396. {
  397.     fputs("usage: ref [-a] [-t] [-c class] [-f file] tag\n", stderr);
  398.     fputs("   -a        function's args may be flush against left margin\n", stderr);
  399.     fputs("   -t        output tag info, instead of the function header\n", stderr);
  400.     fputs("   -f File   tag might be a static function in File\n", stderr);
  401.     fputs("   -c Class  tag might be a member of class Class\n", stderr);
  402.     exit(2);
  403. }
  404.  
  405.  
  406. int countcolons(str)
  407.     char    *str;
  408. {
  409.     while (*str != ':' && *str)
  410.     {
  411.         str++;
  412.     }
  413.     if (str[0] != ':')
  414.     {
  415.         return 0;
  416.     }
  417.     else if (str[1] != ':')
  418.     {
  419.         return 1;
  420.     }
  421.     return 2;
  422. }
  423.  
  424. int main(argc, argv)
  425.     int    argc;
  426.     char    **argv;
  427. {
  428.     char    def_tag[100];    /* used to build tag name with default file/class */
  429.     int    i;
  430.  
  431.     /* parse flags */
  432.     for (i = 1; i < argc && argv[i][0] == '-'; i++)
  433.     {
  434.         switch (argv[i][1])
  435.         {
  436.           case 't':
  437.             taginfo = 1;
  438.             break;
  439.  
  440.           case 'f':
  441.             if (argv[i][2])
  442.             {
  443.                 def_file = &argv[i][2];
  444.             }
  445.             else if (++i < argc)
  446.             {
  447.                 def_file = argv[i];
  448.             }
  449.             else
  450.             {
  451.                 usage();
  452.             }
  453.             break;
  454.  
  455.           case 'c':
  456.             if (argv[i][2])
  457.             {
  458.                 def_class = &argv[i][2];
  459.             }
  460.             else if (++i < argc)
  461.             {
  462.                 def_class = argv[i];
  463.             }
  464.             else
  465.             {
  466.                 usage();
  467.             }
  468.             break;
  469.  
  470.           default:
  471.             usage();
  472.         }
  473.     }
  474.  
  475.     /* if no tag was given, complain */
  476.     if (i + 1 != argc)
  477.     {
  478.         usage();
  479.     }
  480.  
  481.     /* does the tag have an explicit class or file? */
  482.     colons = countcolons(argv[i]);
  483.  
  484.     /* if not, then maybe try some defaults */
  485.     if (colons == 0)
  486.     {
  487.         /* try a static function in the file first */
  488.         if (def_file)
  489.         {
  490.             sprintf(def_tag, "%s:%s", def_file, argv[i]);
  491.             colons = 1;
  492.             if (find(def_tag))
  493.             {
  494.                 exit(0);
  495.             }
  496.         }
  497.  
  498.         /* try a member function for a class */
  499.         if (def_class)
  500.         {
  501.             sprintf(def_tag, "%s::%s", def_class, argv[i]);
  502.             colons = 2;
  503.             if (find(def_tag))
  504.             {
  505.                 exit(0);
  506.             }
  507.         }
  508.  
  509.         /* oh, well */
  510.         colons = 0;
  511.     }
  512.  
  513.     /* find the tag */
  514.     if (find(argv[i]))
  515.     {
  516.         exit(0);
  517.     }
  518.  
  519.     exit(1);
  520.     /*NOTREACHED*/
  521. }
  522.